#include "TcpServer.h"
#include "Logger.h"
#include "TcpConnection.h"

#include <strings.h>
#include <functional>

// 静态辅助函数, 用于确保传入的EventLoop指针非空 EventLoop loop;
static EventLoop* CheckLoopNotNull(EventLoop *loop)
{
    if (loop == nullptr)
    {
        // 如果loop为空, 则记录致命错误并终止程序
        LOG_FATAL("%s:%s:%d mainLoop is null! \n", __FILE__, __FUNCTION__, __LINE__);
    }
    return loop;
}

TcpServer::TcpServer(EventLoop *loop,
                const InetAddress &listenAddr,
                const std::string &nameArg,
                Option option)
                : loop_(CheckLoopNotNull(loop))  // 确保传入的EventLoop指针非空
                , ipPort_(listenAddr.toIpPort())  // 获取监听地址的IP和端口字符串
                , name_(nameArg) // 设置服务器名称
                , acceptor_(new Acceptor(loop, listenAddr, option == kReusePort)) // 创建Acceptor对象，用于接受新连接
                , threadPool_(new EventLoopThreadPool(loop, name_)) // 默认只有主线程(mainLoop),还没有开启线程
                , connectionCallback_() // 初始化连接回调函数
                , messageCallback_()  // 初始化消息回调函数
                , nextConnId_(1)  // 初始化连接ID
                , started_(0) // 初始化服务器启动状态
{
    // 当有新用户连接时，会执行TcpServer::newConnection函数回调
    // std::placeholders::_1 和 std::placeholders::_2，这两个占位符表示，在 newConnection 方法被调用时，这两个占位符将会被 Acceptor 传递的参数替换。
    acceptor_->setNewConnectionCallback(std::bind(&TcpServer::newConnection, this, 
        std::placeholders::_1, std::placeholders::_2));
}

// 析构函数
TcpServer::~TcpServer()
{
    for (auto &item : connections_)
    {
        // 这个局部的shared_ptr智能指针对象，出右括号，可以自动释放new出来的TcpConnection对象资源了
        TcpConnectionPtr conn(item.second); 
        item.second.reset();

        // 销毁连接
        // 如果直接调用 reset() 方法, 没有 conn 局部对象, 就没办法调用 getLoop() 方法了 
        conn->getLoop()->runInLoop(
            std::bind(&TcpConnection::connectDestroyed, conn)
        );
    }
}

// 设置底层subloop的个数
void TcpServer::setThreadNum(int numThreads)
{
    threadPool_->setThreadNum(numThreads);
}

// 开启服务器监听   loop.loop()
void TcpServer::start()
{
    if (started_++ == 0) // 防止一个TcpServer对象被start多次
    {
        /**
         * threadInitCallback_ 回调函数是用户可以设置的线程初始化回调函数，用于初始化线程池中的每个线程。
         * acceptor_.get()返回Acceptor对象的原始指针,用于将Acceptor对象的listen()方法绑定到loop_的事件循环中执行。
        */
        threadPool_->start(threadInitCallback_); // 启动底层的loop线程池
        loop_->runInLoop(std::bind(&Acceptor::listen, acceptor_.get())); // 在主EventLoop中执行监听操作
    }
}

// localAddr：这是服务器端的本地地址，即 TcpServer 类所绑定的 IP 地址和端口号。
// peerAddr：这是客户端的远程地址，即连接到服务器的客户端的 IP 地址和端口号。
void TcpServer::newConnection(int sockfd, const InetAddress &peerAddr)
{
    // 轮询算法，选择一个subLoop，来管理channel
    EventLoop *ioLoop = threadPool_->getNextLoop(); 
    char buf[64] = {0};
    snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_); // 格式化生成新连接的名称
    ++nextConnId_; // 增加连接ID计数
    std::string connName = name_ + buf; // 完整的连接名称

    LOG_INFO("TcpServer::newConnection [%s] - new connection [%s] from %s \n",
        name_.c_str(), connName.c_str(), peerAddr.toIpPort().c_str());

    // 通过sockfd获取其绑定的本机的ip地址和端口信息
    struct sockaddr_in local;
    ::bzero(&local, sizeof local);
    socklen_t addrlen = sizeof local;
    // getsockname() 这个函数的作用是获取与某个套接字相关联的本地地址（即绑定的IP地址和端口号）
    if (::getsockname(sockfd, (sockaddr*)&local, &addrlen) < 0)
    {
        LOG_ERROR("sockets::getLocalAddr");
    }
    InetAddress localAddr(local);

    // 根据连接成功的sockfd，创建TcpConnection连接对象
    TcpConnectionPtr conn(new TcpConnection(ioLoop, connName, sockfd, localAddr, peerAddr));
    connections_[connName] = conn;
    // 下面的回调都是用户设置给TcpServer=>TcpConnection=>Channel=>Poller=>notify channel调用回调
    conn->setConnectionCallback(connectionCallback_);
    conn->setMessageCallback(messageCallback_); // send()函数；
    conn->setWriteCompleteCallback(writeCompleteCallback_);

    // 设置了如何关闭连接的回调   conn->shutDown()
    conn->setCloseCallback(
        std::bind(&TcpServer::removeConnection, this, std::placeholders::_1)
    );

    // 直接调用TcpConnection::connectEstablished，在连接所属的EventLoop中执行连接建立操作
    ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}

// 移除连接
void TcpServer::removeConnection(const TcpConnectionPtr &conn)
{
    loop_->runInLoop(
        std::bind(&TcpServer::removeConnectionInLoop, this, conn)
    );
}

// 在EventLoop中移除连接
void TcpServer::removeConnectionInLoop(const TcpConnectionPtr &conn)
{
    LOG_INFO("TcpServer::removeConnectionInLoop [%s] - connection %s\n", 
        name_.c_str(), conn->name().c_str());

    connections_.erase(conn->name()); // 从连接管理中移除指定的连接
    EventLoop *ioLoop = conn->getLoop(); 
    ioLoop->queueInLoop(
        std::bind(&TcpConnection::connectDestroyed, conn) // 在EventLoop中安排销毁连接的任务
    );
}

